﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.IO;

namespace Velocity4Net.Runtime.Parse
{
    /** Token Manager. */
    public class ParserTokenManager : ParserConstants
    {
        private int fileDepth = 0;

        private int lparen = 0;
        private int rparen = 0;

        ArrayList stateStack = new ArrayList(50);

        public bool debugPrint = false;

        private bool inReference;
        public bool inDirective;
        private bool inComment;
        public bool inSet;

        /**
         *  pushes the current state onto the 'state stack',
         *  and maintains the parens counts
         *  public because we need it in PD & VM handling
         *
         *  @return bool : success.  It can fail if the state machine
         *     gets messed up (do don't mess it up :)
         */
        public bool stateStackPop()
        {
            ParserState s = null;
            try
            {
                // s = (ParserState) stateStack.remove(stateStack.Count - 1); // stack.pop

                s = (ParserState)stateStack[stateStack.Count - 1];
                stateStack.Remove(s);
            }
            catch (InvalidOperationException e)
            {
                // empty stack
                lparen = 0;
                SwitchTo(DEFAULT);
                return false;
            }

            if (debugPrint)
                Console.WriteLine(
                    " stack pop (" + stateStack.Count + ") : lparen=" +
                        s.lparen +
                            " newstate=" + s.lexstate);

            lparen = s.lparen;
            rparen = s.rparen;

            SwitchTo(s.lexstate);

            return true;
        }

        /**
         *  pops a state off the stack, and restores paren counts
         *
         *  @return bool : success of operation
         */
        public bool stateStackPush()
        {
            if (debugPrint)
                Console.WriteLine(" (" + stateStack.Count + ") pushing cur state : " +
                    curLexState);

            ParserState s = new ParserState();
            s.lparen = lparen;
            s.rparen = rparen;
            s.lexstate = curLexState;

            lparen = 0;
            stateStack.Add(s); // stack.push

            return true;
        }

        /**
         *  Clears all state variables, resets to
         *  start values, clears stateStack.  Call
         *  before parsing.
         */
        public void clearStateVars()
        {
            stateStack.Clear();

            lparen = 0;
            rparen = 0;
            inReference = false;
            inDirective = false;
            inComment = false;
            inSet = false;

            return;
        }

        /**
         * Holds the state of the parsing process.
         */
        private class ParserState
        {
            public int lparen;
            public int rparen;
            public int lexstate;
        }

        /**
         *  handles the dropdown logic when encountering a RPAREN
         */
        private void RPARENHandler()
        {
            /*
             *  Ultimately, we want to drop down to the state below
             *  the one that has an open (if we hit bottom (DEFAULT),
             *  that's fine. It's just text schmoo.
             */

            bool closed = false;

            if (inComment)
                closed = true;

            while (!closed)
            {
                /*
                 * look at current state.  If we haven't seen a lparen
                 * in this state then we drop a state, because this
                 * lparen clearly closes our state
                 */

                if (lparen > 0)
                {
                    /*
                     *  if rparen + 1 == lparen, then this state is closed.
                     * Otherwise, increment and keep parsing
                     */

                    if (lparen == rparen + 1)
                    {
                        stateStackPop();
                    }
                    else
                    {
                        rparen++;
                    }

                    closed = true;
                }
                else
                {
                    /*
                     * now, drop a state
                     */

                    if (!stateStackPop())
                        break;
                }
            }
        }

        /** Debug output. */
        public TextWriter debugStream = Console.Out;
        /** Set debug output. */
        public void setDebugStream(TextWriter ds) { debugStream = ds; }
        private int jjStopStringLiteralDfa_3(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x1000000000L) != 0L)
                        return 105;
                    if ((active0 & 0x100L) != 0L)
                        return 69;
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 61;
                        return 67;
                    }
                    if ((active0 & 0x40L) != 0L)
                        return 62;
                    if ((active0 & 0x4000000000000L) != 0L)
                        return 54;
                    if ((active0 & 0x3a0000L) != 0L)
                        return 7;
                    return -1;
                case 1:
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 61;
                        jjmatchedPos = 1;
                        return 67;
                    }
                    if ((active0 & 0x80000L) != 0L)
                        return 5;
                    return -1;
                case 2:
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 61;
                        jjmatchedPos = 2;
                        return 67;
                    }
                    return -1;
                case 3:
                    if ((active0 & 0x200000000L) != 0L)
                        return 67;
                    if ((active0 & 0x400000000L) != 0L)
                    {
                        jjmatchedKind = 61;
                        jjmatchedPos = 3;
                        return 67;
                    }
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_3(int pos, long active0)
        {
            return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
        }
        private int jjStopAtPos(int pos, int kind)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            return pos + 1;
        }
        private int jjMoveStringLiteralDfa0_3()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_3(0x2a0000L);
                case '%':
                    return jjStopAtPos(0, 40);
                case '(':
                    return jjStopAtPos(0, 10);
                case '*':
                    return jjStopAtPos(0, 38);
                case '+':
                    return jjStopAtPos(0, 37);
                case ',':
                    return jjStopAtPos(0, 5);
                case '-':
                    return jjStartNfaWithStates_3(0, 36, 105);
                case '.':
                    return jjMoveStringLiteralDfa1_3(0x40L);
                case '/':
                    return jjStopAtPos(0, 39);
                case ':':
                    return jjStopAtPos(0, 7);
                case '=':
                    return jjStartNfaWithStates_3(0, 50, 54);
                case '[':
                    return jjStopAtPos(0, 3);
                case ']':
                    return jjStopAtPos(0, 4);
                case 'f':
                    return jjMoveStringLiteralDfa1_3(0x400000000L);
                case 't':
                    return jjMoveStringLiteralDfa1_3(0x200000000L);
                case '{':
                    return jjStartNfaWithStates_3(0, 8, 69);
                case '}':
                    return jjStopAtPos(0, 9);
                default:
                    return jjMoveNfa_3(0, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_3(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_3(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '#':
                    if ((active0 & 0x200000L) != 0L)
                        return jjStopAtPos(1, 21);
                    break;
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_3(1, 19, 5);
                    break;
                case '.':
                    if ((active0 & 0x40L) != 0L)
                        return jjStopAtPos(1, 6);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_3(active0, 0x20000L);
                case 'a':
                    return jjMoveStringLiteralDfa2_3(active0, 0x400000000L);
                case 'r':
                    return jjMoveStringLiteralDfa2_3(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_3(0, active0);
        }
        private int jjMoveStringLiteralDfa2_3(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_3(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_3(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                case 'l':
                    return jjMoveStringLiteralDfa3_3(active0, 0x400000000L);
                case 'u':
                    return jjMoveStringLiteralDfa3_3(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_3(1, active0);
        }
        private int jjMoveStringLiteralDfa3_3(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_3(1, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_3(2, active0);
                return 3;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x200000000L) != 0L)
                        return jjStartNfaWithStates_3(3, 33, 67);
                    break;
                case 's':
                    return jjMoveStringLiteralDfa4_3(active0, 0x400000000L);
                default:
                    break;
            }
            return jjStartNfa_3(2, active0);
        }
        private int jjMoveStringLiteralDfa4_3(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_3(2, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_3(3, active0);
                return 4;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x400000000L) != 0L)
                        return jjStartNfaWithStates_3(4, 34, 67);
                    break;
                default:
                    break;
            }
            return jjStartNfa_3(3, active0);
        }
        private int jjStartNfaWithStates_3(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_3(state, pos + 1);
        }
        static ulong[] jjbitVec0 = {
   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
};
        static ulong[] jjbitVec2 = {
   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
};
        private int jjMoveNfa_3(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 105;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 105:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(100, 101);
                                else if (curChar == 46)
                                    jjCheckNAdd(62);
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(94, 95);
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                {
                                    if (kind > 56)
                                        kind = 56;
                                    jjCheckNAddTwoStates(91, 93);
                                }
                                break;
                            case 0:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                {
                                    if (kind > 56)
                                        kind = 56;
                                    jjCheckNAddStates(0, 5);
                                }
                                else if ((0x100002600L & (ulong)l) != 0L)
                                {
                                    if (kind > 31)
                                        kind = 31;
                                    jjCheckNAdd(9);
                                }
                                else if (curChar == 45)
                                    jjCheckNAddStates(6, 9);
                                else if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(77, 78);
                                }
                                else if (curChar == 46)
                                    jjCheckNAdd(62);
                                else if (curChar == '!')
                                {
                                    if (kind > 49)
                                        kind = 49;
                                }
                                else if (curChar == 61)
                                    jjstateSet[jjnewStateCnt++] = 54;
                                else if (curChar == 62)
                                    jjstateSet[jjnewStateCnt++] = 52;
                                else if (curChar == 60)
                                    jjstateSet[jjnewStateCnt++] = 49;
                                else if (curChar == 38)
                                    jjstateSet[jjnewStateCnt++] = 39;
                                else if (curChar == 39)
                                    jjCheckNAddStates(10, 13);
                                else if (curChar == 34)
                                    jjCheckNAddStates(14, 17);
                                else if (curChar == '#')
                                    jjstateSet[jjnewStateCnt++] = 7;
                                else if (curChar == 41)
                                {
                                    if (kind > 11)
                                        kind = 11;
                                    jjCheckNAddStates(18, 20);
                                }
                                if ((0x2400L & (ulong)l) != 0L)
                                {
                                    if (kind > 35)
                                        kind = 35;
                                }
                                else if (curChar == '!')
                                    jjstateSet[jjnewStateCnt++] = 58;
                                else if (curChar == 62)
                                {
                                    if (kind > 45)
                                        kind = 45;
                                }
                                else if (curChar == 60)
                                {
                                    if (kind > 43)
                                        kind = 43;
                                }
                                if (curChar == 13)
                                    jjstateSet[jjnewStateCnt++] = 37;
                                break;
                            case 1:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddStates(18, 20);
                                break;
                            case 2:
                                if ((0x2400L & (ulong)l) != 0L && kind > 11)
                                    kind = 11;
                                break;
                            case 3:
                                if (curChar == 10 && kind > 11)
                                    kind = 11;
                                break;
                            case 4:
                                if (curChar == 13)
                                    jjstateSet[jjnewStateCnt++] = 3;
                                break;
                            case 5:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 6;
                                break;
                            case 6:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            case 7:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 8:
                                if (curChar == '#')
                                    jjstateSet[jjnewStateCnt++] = 7;
                                break;
                            case 9:
                                if ((0x100002600L & (ulong)l) == 0L)
                                    break;
                                if (kind > 31)
                                    kind = 31;
                                jjCheckNAdd(9);
                                break;
                            case 10:
                            case 12:
                                if (curChar == 34)
                                    jjCheckNAddStates(14, 17);
                                break;
                            case 11:
                                if ((0xfffffffbffffffffL & (ulong)l) != 0L)
                                    jjCheckNAddStates(14, 17);
                                break;
                            case 13:
                                if (curChar == 34)
                                    jjstateSet[jjnewStateCnt++] = 12;
                                break;
                            case 14:
                                if (curChar == 34 && kind > 32)
                                    kind = 32;
                                break;
                            case 17:
                                if ((0xff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(21, 25);
                                break;
                            case 18:
                                if ((0xff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(14, 17);
                                break;
                            case 19:
                                if ((0xf000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 20;
                                break;
                            case 20:
                                if ((0xff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(18);
                                break;
                            case 22:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 23;
                                break;
                            case 23:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 24;
                                break;
                            case 24:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 25;
                                break;
                            case 25:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(14, 17);
                                break;
                            case 26:
                                if (curChar == 32)
                                    jjAddStates(26, 27);
                                break;
                            case 27:
                                if (curChar == 10)
                                    jjCheckNAddStates(14, 17);
                                break;
                            case 28:
                            case 30:
                                if (curChar == 39)
                                    jjCheckNAddStates(10, 13);
                                break;
                            case 29:
                                if ((0xffffff7fffffffffL & (ulong)l) != 0L)
                                    jjCheckNAddStates(10, 13);
                                break;
                            case 31:
                                if (curChar == 39)
                                    jjstateSet[jjnewStateCnt++] = 30;
                                break;
                            case 33:
                                if (curChar == 32)
                                    jjAddStates(28, 29);
                                break;
                            case 34:
                                if (curChar == 10)
                                    jjCheckNAddStates(10, 13);
                                break;
                            case '#':
                                if (curChar == 39 && kind > 32)
                                    kind = 32;
                                break;
                            case 36:
                                if ((0x2400L & (ulong)l) != 0L && kind > 35)
                                    kind = 35;
                                break;
                            case 37:
                                if (curChar == 10 && kind > 35)
                                    kind = 35;
                                break;
                            case 38:
                                if (curChar == 13)
                                    jjstateSet[jjnewStateCnt++] = 37;
                                break;
                            case 39:
                                if (curChar == 38 && kind > 41)
                                    kind = 41;
                                break;
                            case '(':
                                if (curChar == 38)
                                    jjstateSet[jjnewStateCnt++] = 39;
                                break;
                            case 48:
                                if (curChar == 60 && kind > 43)
                                    kind = 43;
                                break;
                            case 49:
                                if (curChar == 61 && kind > 44)
                                    kind = 44;
                                break;
                            case 50:
                                if (curChar == 60)
                                    jjstateSet[jjnewStateCnt++] = 49;
                                break;
                            case 51:
                                if (curChar == 62 && kind > 45)
                                    kind = 45;
                                break;
                            case 52:
                                if (curChar == 61 && kind > 46)
                                    kind = 46;
                                break;
                            case 53:
                                if (curChar == 62)
                                    jjstateSet[jjnewStateCnt++] = 52;
                                break;
                            case 54:
                                if (curChar == 61 && kind > 47)
                                    kind = 47;
                                break;
                            case 55:
                                if (curChar == 61)
                                    jjstateSet[jjnewStateCnt++] = 54;
                                break;
                            case ':':
                                if (curChar == 61 && kind > 48)
                                    kind = 48;
                                break;
                            case 59:
                                if (curChar == '!')
                                    jjstateSet[jjnewStateCnt++] = 58;
                                break;
                            case 60:
                                if (curChar == '!' && kind > 49)
                                    kind = 49;
                                break;
                            case 61:
                                if (curChar == 46)
                                    jjCheckNAdd(62);
                                break;
                            case 62:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(62, 63);
                                break;
                            case 64:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(65);
                                break;
                            case 65:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(65);
                                break;
                            case 67:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 61)
                                    kind = 61;
                                jjstateSet[jjnewStateCnt++] = 67;
                                break;
                            case 70:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjAddStates(30, 31);
                                break;
                            case 74:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 76:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(77, 78);
                                break;
                            case 78:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 79:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(77, 78);
                                break;
                            case 90:
                                if (curChar == 45)
                                    jjCheckNAddStates(6, 9);
                                break;
                            case '[':
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 56)
                                    kind = 56;
                                jjCheckNAddTwoStates(91, 93);
                                break;
                            case '\\':
                                if (curChar == 46 && kind > 56)
                                    kind = 56;
                                break;
                            case ']':
                                if (curChar == 46)
                                    jjstateSet[jjnewStateCnt++] = 92;
                                break;
                            case 94:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(94, 95);
                                break;
                            case 95:
                                if (curChar != 46)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(96, 97);
                                break;
                            case 96:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(96, 97);
                                break;
                            case 98:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(99);
                                break;
                            case 99:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(99);
                                break;
                            case 100:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(100, 101);
                                break;
                            case 'f':
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(103);
                                break;
                            case 103:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(103);
                                break;
                            case 104:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 56)
                                    kind = 56;
                                jjCheckNAddStates(0, 5);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 0:
                                if ((0x7fffffe87ffffffL & (ulong)l) != 0L)
                                {
                                    if (kind > 61)
                                        kind = 61;
                                    jjCheckNAdd(67);
                                }
                                else if (curChar == '\\')
                                    jjCheckNAddStates(32, 35);
                                else if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 69;
                                else if (curChar == 124)
                                    jjstateSet[jjnewStateCnt++] = 44;
                                if (curChar == 110)
                                    jjAddStates(36, 37);
                                else if (curChar == 103)
                                    jjAddStates(38, 39);
                                else if (curChar == 108)
                                    jjAddStates(40, 41);
                                else if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 56;
                                else if (curChar == 111)
                                    jjstateSet[jjnewStateCnt++] = 46;
                                else if (curChar == 97)
                                    jjstateSet[jjnewStateCnt++] = 42;
                                break;
                            case 6:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            case 11:
                                jjCheckNAddStates(14, 17);
                                break;
                            case 15:
                                if (curChar == '\\')
                                    jjAddStates(42, 47);
                                break;
                            case 16:
                                if ((0x14404400000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(14, 17);
                                break;
                            case 21:
                                if (curChar == 117)
                                    jjstateSet[jjnewStateCnt++] = 22;
                                break;
                            case 22:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 23;
                                break;
                            case 23:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 24;
                                break;
                            case 24:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 25;
                                break;
                            case 25:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjCheckNAddStates(14, 17);
                                break;
                            case 29:
                                jjAddStates(10, 13);
                                break;
                            case 32:
                                if (curChar == '\\')
                                    jjAddStates(28, 29);
                                break;
                            case ')':
                                if (curChar == 100 && kind > 41)
                                    kind = 41;
                                break;
                            case '*':
                                if (curChar == 110)
                                    jjstateSet[jjnewStateCnt++] = 41;
                                break;
                            case 43:
                                if (curChar == 97)
                                    jjstateSet[jjnewStateCnt++] = 42;
                                break;
                            case ',':
                                if (curChar == 124 && kind > 42)
                                    kind = 42;
                                break;
                            case 45:
                                if (curChar == 124)
                                    jjstateSet[jjnewStateCnt++] = 44;
                                break;
                            case '.':
                                if (curChar == 114 && kind > 42)
                                    kind = 42;
                                break;
                            case 47:
                                if (curChar == 111)
                                    jjstateSet[jjnewStateCnt++] = 46;
                                break;
                            case 56:
                                if (curChar == 113 && kind > 47)
                                    kind = 47;
                                break;
                            case 57:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 56;
                                break;
                            case 63:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(48, 49);
                                break;
                            case 66:
                            case 67:
                                if ((0x7fffffe87ffffffL & (ulong)l) == 0L)
                                    break;
                                if (kind > 61)
                                    kind = 61;
                                jjCheckNAdd(67);
                                break;
                            case 68:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 69;
                                break;
                            case 69:
                                if ((0x7fffffe87fffffeL & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(70, 71);
                                break;
                            case 70:
                                if ((0x7fffffe87ffffffL & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(70, 71);
                                break;
                            case 71:
                                if (curChar == '}' && kind > 62)
                                    kind = 62;
                                break;
                            case 72:
                                if (curChar == '\\')
                                    jjCheckNAddStates(32, 35);
                                break;
                            case 73:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(73, 74);
                                break;
                            case 75:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(75, 76);
                                break;
                            case 77:
                                if (curChar == '\\')
                                    jjAddStates(50, 51);
                                break;
                            case 80:
                                if (curChar == 108)
                                    jjAddStates(40, 41);
                                break;
                            case 81:
                                if (curChar == 't' && kind > 43)
                                    kind = 43;
                                break;
                            case 82:
                                if (curChar == 'e' && kind > 44)
                                    kind = 44;
                                break;
                            case 83:
                                if (curChar == 103)
                                    jjAddStates(38, 39);
                                break;
                            case 84:
                                if (curChar == 't' && kind > 45)
                                    kind = 45;
                                break;
                            case 85:
                                if (curChar == 'e' && kind > 46)
                                    kind = 46;
                                break;
                            case 86:
                                if (curChar == 110)
                                    jjAddStates(36, 37);
                                break;
                            case 87:
                                if (curChar == 'e' && kind > 48)
                                    kind = 48;
                                break;
                            case 88:
                                if (curChar == 't' && kind > 49)
                                    kind = 49;
                                break;
                            case 89:
                                if (curChar == 111)
                                    jjstateSet[jjnewStateCnt++] = 88;
                                break;
                            case 'a':
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(52, 53);
                                break;
                            case 'e':
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(54, 55);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 6:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            case 11:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                    jjAddStates(14, 17);
                                break;
                            case 29:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                    jjAddStates(10, 13);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 105 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_11(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x3a0000L) != 0L)
                        return 2;
                    return -1;
                case 1:
                    if ((active0 & 0x80000L) != 0L)
                        return 0;
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_11(int pos, long active0)
        {
            return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_11()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_11(0x2a0000L);
                default:
                    return jjMoveNfa_11(3, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_11(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_11(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '#':
                    if ((active0 & 0x200000L) != 0L)
                        return jjStopAtPos(1, 21);
                    break;
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_11(1, 19, 0);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_11(active0, 0x20000L);
                default:
                    break;
            }
            return jjStartNfa_11(0, active0);
        }
        private int jjMoveStringLiteralDfa2_11(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_11(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_11(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                default:
                    break;
            }
            return jjStartNfa_11(1, active0);
        }
        private int jjStartNfaWithStates_11(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_11(state, pos + 1);
        }
        private int jjMoveNfa_11(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 83;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                {
                                    if (kind > 56)
                                        kind = 56;
                                    jjCheckNAddStates(56, 61);
                                }
                                else if (curChar == 45)
                                    jjCheckNAddStates(62, 65);
                                else if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(22, 23);
                                }
                                else if (curChar == 46)
                                    jjCheckNAdd(7);
                                else if (curChar == '#')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 0:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 1;
                                break;
                            case 1:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            case 2:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 0;
                                break;
                            case 6:
                                if (curChar == 46)
                                    jjCheckNAdd(7);
                                break;
                            case 7:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(7, 8);
                                break;
                            case 9:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(10);
                                break;
                            case 10:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(10);
                                break;
                            case 12:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 61)
                                    kind = 61;
                                jjstateSet[jjnewStateCnt++] = 12;
                                break;
                            case 15:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjAddStates(66, 67);
                                break;
                            case 19:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 21:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(22, 23);
                                break;
                            case 23:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 24:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(22, 23);
                                break;
                            case 27:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddStates(68, 70);
                                break;
                            case 28:
                                if ((0x2400L & (ulong)l) != 0L && kind > 51)
                                    kind = 51;
                                break;
                            case 29:
                                if (curChar == 10 && kind > 51)
                                    kind = 51;
                                break;
                            case 30:
                            case 47:
                                if (curChar == 13)
                                    jjCheckNAdd(29);
                                break;
                            case 38:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddStates(71, 73);
                                break;
                            case 39:
                                if ((0x2400L & (ulong)l) != 0L && kind > 54)
                                    kind = 54;
                                break;
                            case '(':
                                if (curChar == 10 && kind > 54)
                                    kind = 54;
                                break;
                            case ')':
                            case 63:
                                if (curChar == 13)
                                    jjCheckNAdd(40);
                                break;
                            case '.':
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddStates(74, 76);
                                break;
                            case 62:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddStates(77, 79);
                                break;
                            case 68:
                                if (curChar == 45)
                                    jjCheckNAddStates(62, 65);
                                break;
                            case 69:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 56)
                                    kind = 56;
                                jjCheckNAddTwoStates(69, 71);
                                break;
                            case 70:
                                if (curChar == 46 && kind > 56)
                                    kind = 56;
                                break;
                            case 71:
                                if (curChar == 46)
                                    jjstateSet[jjnewStateCnt++] = 70;
                                break;
                            case 72:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(72, 73);
                                break;
                            case 73:
                                if (curChar != 46)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(74, 75);
                                break;
                            case 74:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(74, 75);
                                break;
                            case 76:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(77);
                                break;
                            case 77:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(77);
                                break;
                            case 78:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(78, 79);
                                break;
                            case 80:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(81);
                                break;
                            case 81:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(81);
                                break;
                            case 82:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 56)
                                    kind = 56;
                                jjCheckNAddStates(56, 61);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x7fffffe87ffffffL & (ulong)l) != 0L)
                                {
                                    if (kind > 61)
                                        kind = 61;
                                    jjCheckNAdd(12);
                                }
                                else if (curChar == '{')
                                    jjAddStates(80, 83);
                                else if (curChar == '\\')
                                    jjCheckNAddStates(84, 87);
                                if (curChar == 'e')
                                    jjAddStates(88, 90);
                                else if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 14;
                                else if (curChar == 105)
                                    jjstateSet[jjnewStateCnt++] = 4;
                                break;
                            case 1:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            case 4:
                                if (curChar == 102 && kind > 52)
                                    kind = 52;
                                break;
                            case 5:
                                if (curChar == 105)
                                    jjstateSet[jjnewStateCnt++] = 4;
                                break;
                            case 8:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(91, 92);
                                break;
                            case 11:
                            case 12:
                                if ((0x7fffffe87ffffffL & (ulong)l) == 0L)
                                    break;
                                if (kind > 61)
                                    kind = 61;
                                jjCheckNAdd(12);
                                break;
                            case 13:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 14;
                                break;
                            case 14:
                                if ((0x7fffffe87fffffeL & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(15, 16);
                                break;
                            case 15:
                                if ((0x7fffffe87ffffffL & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(15, 16);
                                break;
                            case 16:
                                if (curChar == '}' && kind > 62)
                                    kind = 62;
                                break;
                            case 17:
                                if (curChar == '\\')
                                    jjCheckNAddStates(84, 87);
                                break;
                            case 18:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(18, 19);
                                break;
                            case 20:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(20, 21);
                                break;
                            case 22:
                                if (curChar == '\\')
                                    jjAddStates(93, 94);
                                break;
                            case 25:
                                if (curChar == 'e')
                                    jjAddStates(88, 90);
                                break;
                            case 26:
                                if (curChar != 100)
                                    break;
                                if (kind > 51)
                                    kind = 51;
                                jjCheckNAddStates(68, 70);
                                break;
                            case 31:
                                if (curChar == 110)
                                    jjstateSet[jjnewStateCnt++] = 26;
                                break;
                            case 32:
                                if (curChar == 102 && kind > 53)
                                    kind = 53;
                                break;
                            case 33:
                                if (curChar == 105)
                                    jjstateSet[jjnewStateCnt++] = 32;
                                break;
                            case 34:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 33;
                                break;
                            case '#':
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 34;
                                break;
                            case 36:
                                if (curChar == 108)
                                    jjstateSet[jjnewStateCnt++] = 35;
                                break;
                            case 37:
                                if (curChar != 101)
                                    break;
                                if (kind > 54)
                                    kind = 54;
                                jjCheckNAddStates(71, 73);
                                break;
                            case '*':
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 37;
                                break;
                            case 43:
                                if (curChar == 108)
                                    jjstateSet[jjnewStateCnt++] = 42;
                                break;
                            case ',':
                                if (curChar == '{')
                                    jjAddStates(80, 83);
                                break;
                            case 45:
                                if (curChar != 125)
                                    break;
                                if (kind > 51)
                                    kind = 51;
                                jjCheckNAddStates(74, 76);
                                break;
                            case 48:
                                if (curChar == 100)
                                    jjstateSet[jjnewStateCnt++] = 45;
                                break;
                            case 49:
                                if (curChar == 110)
                                    jjstateSet[jjnewStateCnt++] = 48;
                                break;
                            case 50:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 49;
                                break;
                            case 51:
                                if (curChar == '}' && kind > 52)
                                    kind = 52;
                                break;
                            case 52:
                                if (curChar == 102)
                                    jjstateSet[jjnewStateCnt++] = 51;
                                break;
                            case 53:
                                if (curChar == 105)
                                    jjstateSet[jjnewStateCnt++] = 52;
                                break;
                            case 54:
                                if (curChar == '}' && kind > 53)
                                    kind = 53;
                                break;
                            case 55:
                                if (curChar == 102)
                                    jjstateSet[jjnewStateCnt++] = 54;
                                break;
                            case 56:
                                if (curChar == 105)
                                    jjstateSet[jjnewStateCnt++] = 55;
                                break;
                            case 57:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 56;
                                break;
                            case ':':
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 57;
                                break;
                            case 59:
                                if (curChar == 108)
                                    jjstateSet[jjnewStateCnt++] = 58;
                                break;
                            case 60:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 59;
                                break;
                            case 61:
                                if (curChar != 125)
                                    break;
                                if (kind > 54)
                                    kind = 54;
                                jjCheckNAddStates(77, 79);
                                break;
                            case 64:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 61;
                                break;
                            case 65:
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 64;
                                break;
                            case 66:
                                if (curChar == 108)
                                    jjstateSet[jjnewStateCnt++] = 65;
                                break;
                            case 67:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 66;
                                break;
                            case 75:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(95, 96);
                                break;
                            case 79:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(97, 98);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 83 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_8(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x1a0000L) != 0L)
                        return 2;
                    return -1;
                case 1:
                    if ((active0 & 0x80000L) != 0L)
                        return 0;
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_8(int pos, long active0)
        {
            return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_8()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_8(0xa0000L);
                case '*':
                    return jjMoveStringLiteralDfa1_8(0x8000000L);
                default:
                    return jjMoveNfa_8(3, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_8(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_8(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '#':
                    if ((active0 & 0x8000000L) != 0L)
                        return jjStopAtPos(1, 27);
                    break;
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_8(1, 19, 0);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_8(active0, 0x20000L);
                default:
                    break;
            }
            return jjStartNfa_8(0, active0);
        }
        private int jjMoveStringLiteralDfa2_8(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_8(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_8(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                default:
                    break;
            }
            return jjStartNfa_8(1, active0);
        }
        private int jjStartNfaWithStates_8(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_8(state, pos + 1);
        }
        private int jjMoveNfa_8(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 12;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(9, 10);
                                }
                                else if (curChar == '#')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 0:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 1;
                                break;
                            case 1:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            case 2:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 0;
                                break;
                            case 6:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 8:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(9, 10);
                                break;
                            case 10:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 11:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(9, 10);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '\\')
                                    jjCheckNAddStates(99, 102);
                                break;
                            case 1:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            case 5:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(5, 6);
                                break;
                            case 7:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(7, 8);
                                break;
                            case 9:
                                if (curChar == '\\')
                                    jjAddStates(91, 92);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_6(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x1a0000L) != 0L)
                        return 2;
                    return -1;
                case 1:
                    if ((active0 & 0x80000L) != 0L)
                        return 0;
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_6(int pos, long active0)
        {
            return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_6()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_6(0xa0000L);
                default:
                    return jjMoveNfa_6(3, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_6(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_6(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_6(1, 19, 0);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_6(active0, 0x20000L);
                default:
                    break;
            }
            return jjStartNfa_6(0, active0);
        }
        private int jjMoveStringLiteralDfa2_6(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_6(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_6(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                default:
                    break;
            }
            return jjStartNfa_6(1, active0);
        }
        private int jjStartNfaWithStates_6(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_6(state, pos + 1);
        }
        private int jjMoveNfa_6(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 12;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(9, 10);
                                }
                                else if (curChar == '#')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 0:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 1;
                                break;
                            case 1:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            case 2:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 0;
                                break;
                            case 6:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 8:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(9, 10);
                                break;
                            case 10:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 11:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(9, 10);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '\\')
                                    jjCheckNAddStates(99, 102);
                                break;
                            case 1:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            case 5:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(5, 6);
                                break;
                            case 7:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(7, 8);
                                break;
                            case 9:
                                if (curChar == '\\')
                                    jjAddStates(91, 92);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_5(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0xc00000L) != 0L)
                        return 20;
                    if ((active0 & 0x3a0000L) != 0L)
                        return 39;
                    return -1;
                case 1:
                    if ((active0 & 0x400000L) != 0L)
                        return 40;
                    if ((active0 & 0x80000L) != 0L)
                        return 37;
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_5(int pos, long active0)
        {
            return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_5()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_5(0x2a0000L);
                case '\\':
                    jjmatchedKind = 23;
                    return jjMoveStringLiteralDfa1_5(0x400000L);
                default:
                    return jjMoveNfa_5(13, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_5(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_5(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '#':
                    if ((active0 & 0x200000L) != 0L)
                        return jjStopAtPos(1, 21);
                    break;
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_5(1, 19, 37);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_5(active0, 0x20000L);
                case '\\':
                    if ((active0 & 0x400000L) != 0L)
                        return jjStartNfaWithStates_5(1, 22, 40);
                    break;
                default:
                    break;
            }
            return jjStartNfa_5(0, active0);
        }
        private int jjMoveStringLiteralDfa2_5(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_5(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_5(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                default:
                    break;
            }
            return jjStartNfa_5(1, active0);
        }
        private int jjStartNfaWithStates_5(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_5(state, pos + 1);
        }
        private int jjMoveNfa_5(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 40;
            int stateIndex = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    ulong l = 1ul << curChar;
                    do
                    {
                        switch (jjstateSet[--stateIndex])
                        {
                            case 39:
                                if (curChar == '*')
                                    jjstateSet[jjnewStateCnt++] = 37;
                                break;
                            case 40:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(33, 34);
                                if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                }
                                break;
                            case 13:
                                if ((0xffffffe7ffffffffL & (ulong)l) != 0L)
                                {
                                    if (kind > 24)
                                        kind = 24;
                                    jjCheckNAdd(12);
                                }
                                else if (curChar == '#')
                                    jjCheckNAddStates(103, 105);
                                else if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(33, 34);
                                }
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(0, 1);
                                else if (curChar == '$')
                                    jjCheckNAddStates(106, 109);
                                break;
                            case 20:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(33, 34);
                                else if (curChar == '#')
                                    jjAddStates(110, 111);
                                if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                }
                                break;
                            case 0:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(0, 1);
                                break;
                            case 1:
                                if (curChar == '#')
                                    jjCheckNAddTwoStates(6, 11);
                                break;
                            case 3:
                                if (curChar == ' ')
                                    jjAddStates(112, 113);
                                break;
                            case 4:
                                if (curChar == '(' && kind > 14)
                                    kind = 14;
                                break;
                            case 12:
                                if ((0xffffffe7ffffffffL & (ulong)l) == 0L)
                                    break;
                                if (kind > 24)
                                    kind = 24;
                                jjCheckNAdd(12);
                                break;
                            case 15:
                            case 16:
                                if (curChar == '!')
                                    jjCheckNAdd(14);
                                break;
                            case 18:
                                if (curChar == 46 && kind > 72)
                                    kind = 72;
                                break;
                            case 21:
                                if (curChar == '#')
                                    jjAddStates(110, 111);
                                break;
                            case 23:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 13)
                                    kind = 13;
                                jjstateSet[jjnewStateCnt++] = 23;
                                break;
                            case 26:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjAddStates(26, 27);
                                break;
                            case 30:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 32:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(33, 34);
                                break;
                            case 34:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 35:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(33, 34);
                                break;
                            case 36:
                                if (curChar == '#')
                                    jjCheckNAddStates(103, 105);
                                break;
                            case 37:
                                if (curChar == '*')
                                    jjstateSet[jjnewStateCnt++] = 38;
                                break;
                            case 38:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (stateIndex != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--stateIndex])
                        {
                            case 39:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 10;
                                else if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case '(':
                                if (curChar == '\\')
                                    jjAddStates(114, 115);
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(31, 32);
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(29, 30);
                                break;
                            case 13:
                                if ((0xffffffffefffffffL & (ulong)l) != 0L)
                                {
                                    if (kind > 24)
                                        kind = 24;
                                    jjCheckNAdd(12);
                                }
                                else if (curChar == '\\')
                                    jjCheckNAddStates(116, 119);
                                if (curChar == '\\')
                                    jjAddStates(114, 115);
                                break;
                            case 20:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(31, 32);
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(29, 30);
                                if (curChar == '\\')
                                    jjstateSet[jjnewStateCnt++] = 19;
                                break;
                            case 2:
                                if (curChar == 't')
                                    jjCheckNAddTwoStates(3, 4);
                                break;
                            case 5:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 6:
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 7:
                                if (curChar == '}')
                                    jjCheckNAddTwoStates(3, 4);
                                break;
                            case 8:
                                if (curChar == 't')
                                    jjstateSet[jjnewStateCnt++] = 7;
                                break;
                            case 9:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 8;
                                break;
                            case 10:
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 9;
                                break;
                            case 11:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 10;
                                break;
                            case 12:
                                if ((0xffffffffefffffffL & (ulong)l) == 0L)
                                    break;
                                if (kind > 24)
                                    kind = 24;
                                jjCheckNAdd(12);
                                break;
                            case 14:
                                if (curChar == '[' && kind > 72)
                                    kind = 72;
                                break;
                            case 17:
                                if (curChar == '\\')
                                    jjstateSet[jjnewStateCnt++] = 16;
                                break;
                            case 19:
                                if (curChar == '\\')
                                    jjAddStates(114, 115);
                                break;
                            case 22:
                            case 23:
                                if ((0x7fffffe87ffffffL & (ulong)l) == 0L)
                                    break;
                                if (kind > 13)
                                    kind = 13;
                                jjCheckNAdd(23);
                                break;
                            case 24:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 25;
                                break;
                            case 25:
                                if ((0x7fffffe87fffffeL & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(26, 27);
                                break;
                            case 26:
                                if ((0x7fffffe87ffffffL & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(26, 27);
                                break;
                            case 27:
                                if (curChar == '}' && kind > 13)
                                    kind = 13;
                                break;
                            case 28:
                                if (curChar == '\\')
                                    jjCheckNAddStates(116, 119);
                                break;
                            case 29:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(29, 30);
                                break;
                            case 31:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(31, 32);
                                break;
                            case 33:
                                if (curChar == '\\')
                                    jjAddStates(28, 29);
                                break;
                            case 38:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (stateIndex != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--stateIndex])
                        {
                            case 13:
                            case 12:
                                if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                                    break;
                                if (kind > 24)
                                    kind = 24;
                                jjCheckNAdd(12);
                                break;
                            case 38:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (stateIndex != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                stateIndex = jjnewStateCnt;
                jjnewStateCnt = startsAt;
                startsAt = 40 - jjnewStateCnt;
                if (stateIndex == startsAt)
                    return curPos;
                try
                {
                    curChar = input_stream.ReadChar();
                }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_9(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x1a0000L) != 0L)
                        return 2;
                    return -1;
                case 1:
                    if ((active0 & 0x80000L) != 0L)
                        return 0;
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_9(int pos, long active0)
        {
            return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_9()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_9(0xa0000L);
                case '*':
                    return jjMoveStringLiteralDfa1_9(0x4000000L);
                default:
                    return jjMoveNfa_9(3, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_9(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_9(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '#':
                    if ((active0 & 0x4000000L) != 0L)
                        return jjStopAtPos(1, 26);
                    break;
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_9(1, 19, 0);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_9(active0, 0x20000L);
                default:
                    break;
            }
            return jjStartNfa_9(0, active0);
        }
        private int jjMoveStringLiteralDfa2_9(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_9(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_9(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                default:
                    break;
            }
            return jjStartNfa_9(1, active0);
        }
        private int jjStartNfaWithStates_9(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_9(state, pos + 1);
        }
        private int jjMoveNfa_9(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 12;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(9, 10);
                                }
                                else if (curChar == '#')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 0:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 1;
                                break;
                            case 1:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            case 2:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 0;
                                break;
                            case 6:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 8:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(9, 10);
                                break;
                            case 10:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 11:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(9, 10);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '\\')
                                    jjCheckNAddStates(99, 102);
                                break;
                            case 1:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            case 5:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(5, 6);
                                break;
                            case 7:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(7, 8);
                                break;
                            case 9:
                                if (curChar == '\\')
                                    jjAddStates(91, 92);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_2(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x1a0000L) != 0L)
                        return 2;
                    return -1;
                case 1:
                    if ((active0 & 0x80000L) != 0L)
                        return 0;
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_2(int pos, long active0)
        {
            return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_2()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_2(0xa0000L);
                case ']':
                    return jjStopAtPos(0, 2);
                case 'f':
                    return jjMoveStringLiteralDfa1_2(0x400000000L);
                case 't':
                    return jjMoveStringLiteralDfa1_2(0x200000000L);
                default:
                    return jjMoveNfa_2(3, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_2(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_2(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_2(1, 19, 0);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_2(active0, 0x20000L);
                case 'a':
                    return jjMoveStringLiteralDfa2_2(active0, 0x400000000L);
                case 'r':
                    return jjMoveStringLiteralDfa2_2(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_2(0, active0);
        }
        private int jjMoveStringLiteralDfa2_2(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_2(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_2(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                case 'l':
                    return jjMoveStringLiteralDfa3_2(active0, 0x400000000L);
                case 'u':
                    return jjMoveStringLiteralDfa3_2(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_2(1, active0);
        }
        private int jjMoveStringLiteralDfa3_2(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_2(1, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_2(2, active0);
                return 3;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x200000000L) != 0L)
                        return jjStopAtPos(3, 33);
                    break;
                case 's':
                    return jjMoveStringLiteralDfa4_2(active0, 0x400000000L);
                default:
                    break;
            }
            return jjStartNfa_2(2, active0);
        }
        private int jjMoveStringLiteralDfa4_2(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_2(2, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_2(3, active0);
                return 4;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x400000000L) != 0L)
                        return jjStopAtPos(4, 34);
                    break;
                default:
                    break;
            }
            return jjStartNfa_2(3, active0);
        }
        private int jjStartNfaWithStates_2(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_2(state, pos + 1);
        }
        private int jjMoveNfa_2(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 59;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                {
                                    if (kind > 56)
                                        kind = 56;
                                    jjCheckNAddStates(120, 125);
                                }
                                else if ((0x100002600L & (ulong)l) != 0L)
                                {
                                    if (kind > 31)
                                        kind = 31;
                                    jjCheckNAdd(4);
                                }
                                else if (curChar == 45)
                                    jjCheckNAddStates(126, 129);
                                else if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(41, 42);
                                }
                                else if (curChar == 46)
                                    jjCheckNAdd(32);
                                else if (curChar == 39)
                                    jjCheckNAddStates(130, 133);
                                else if (curChar == 34)
                                    jjCheckNAddStates(134, 137);
                                else if (curChar == '#')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 0:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 1;
                                break;
                            case 1:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            case 2:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 0;
                                break;
                            case 4:
                                if ((0x100002600L & (ulong)l) == 0L)
                                    break;
                                if (kind > 31)
                                    kind = 31;
                                jjCheckNAdd(4);
                                break;
                            case 5:
                            case 7:
                                if (curChar == 34)
                                    jjCheckNAddStates(134, 137);
                                break;
                            case 6:
                                if ((0xfffffffbffffffffL & (ulong)l) != 0L)
                                    jjCheckNAddStates(134, 137);
                                break;
                            case 8:
                                if (curChar == 34)
                                    jjstateSet[jjnewStateCnt++] = 7;
                                break;
                            case 9:
                                if (curChar == 34 && kind > 32)
                                    kind = 32;
                                break;
                            case 12:
                                if ((0xff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(138, 142);
                                break;
                            case 13:
                                if ((0xff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(134, 137);
                                break;
                            case 14:
                                if ((0xf000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 15;
                                break;
                            case 15:
                                if ((0xff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(13);
                                break;
                            case 17:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 18;
                                break;
                            case 18:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 19;
                                break;
                            case 19:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 20;
                                break;
                            case 20:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(134, 137);
                                break;
                            case 21:
                                if (curChar == 32)
                                    jjAddStates(143, 144);
                                break;
                            case 22:
                                if (curChar == 10)
                                    jjCheckNAddStates(134, 137);
                                break;
                            case 23:
                            case 25:
                                if (curChar == 39)
                                    jjCheckNAddStates(130, 133);
                                break;
                            case 24:
                                if ((0xffffff7fffffffffL & (ulong)l) != 0L)
                                    jjCheckNAddStates(130, 133);
                                break;
                            case 26:
                                if (curChar == 39)
                                    jjstateSet[jjnewStateCnt++] = 25;
                                break;
                            case 28:
                                if (curChar == 32)
                                    jjAddStates(145, 146);
                                break;
                            case 29:
                                if (curChar == 10)
                                    jjCheckNAddStates(130, 133);
                                break;
                            case 30:
                                if (curChar == 39 && kind > 32)
                                    kind = 32;
                                break;
                            case 31:
                                if (curChar == 46)
                                    jjCheckNAdd(32);
                                break;
                            case 32:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(32, 33);
                                break;
                            case 34:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(35);
                                break;
                            case '#':
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(35);
                                break;
                            case 38:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case '(':
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(41, 42);
                                break;
                            case '*':
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 43:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(41, 42);
                                break;
                            case ',':
                                if (curChar == 45)
                                    jjCheckNAddStates(126, 129);
                                break;
                            case 45:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 56)
                                    kind = 56;
                                jjCheckNAddTwoStates(45, 47);
                                break;
                            case '.':
                                if (curChar == 46 && kind > 56)
                                    kind = 56;
                                break;
                            case 47:
                                if (curChar == 46)
                                    jjstateSet[jjnewStateCnt++] = 46;
                                break;
                            case 48:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(48, 49);
                                break;
                            case 49:
                                if (curChar != 46)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(50, 51);
                                break;
                            case 50:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(50, 51);
                                break;
                            case 52:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(53);
                                break;
                            case 53:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(53);
                                break;
                            case 54:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(54, 55);
                                break;
                            case 56:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(57);
                                break;
                            case 57:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(57);
                                break;
                            case ':':
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 56)
                                    kind = 56;
                                jjCheckNAddStates(120, 125);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '\\')
                                    jjCheckNAddStates(147, 150);
                                break;
                            case 1:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            case 6:
                                jjCheckNAddStates(134, 137);
                                break;
                            case 10:
                                if (curChar == '\\')
                                    jjAddStates(151, 156);
                                break;
                            case 11:
                                if ((0x14404400000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(134, 137);
                                break;
                            case 16:
                                if (curChar == 117)
                                    jjstateSet[jjnewStateCnt++] = 17;
                                break;
                            case 17:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 18;
                                break;
                            case 18:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 19;
                                break;
                            case 19:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 20;
                                break;
                            case 20:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjCheckNAddStates(134, 137);
                                break;
                            case 24:
                                jjAddStates(130, 133);
                                break;
                            case 27:
                                if (curChar == '\\')
                                    jjAddStates(145, 146);
                                break;
                            case 33:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(157, 158);
                                break;
                            case 37:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(37, 38);
                                break;
                            case 39:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(39, 40);
                                break;
                            case ')':
                                if (curChar == '\\')
                                    jjAddStates(159, 160);
                                break;
                            case 51:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(161, 162);
                                break;
                            case 55:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(163, 164);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            case 6:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                    jjAddStates(134, 137);
                                break;
                            case 24:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                    jjAddStates(130, 133);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 59 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_10(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x1a0000L) != 0L)
                        return 2;
                    return -1;
                case 1:
                    if ((active0 & 0x80000L) != 0L)
                        return 0;
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_10(int pos, long active0)
        {
            return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_10()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_10(0xa0000L);
                default:
                    return jjMoveNfa_10(3, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_10(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_10(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_10(1, 19, 0);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_10(active0, 0x20000L);
                default:
                    break;
            }
            return jjStartNfa_10(0, active0);
        }
        private int jjMoveStringLiteralDfa2_10(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_10(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_10(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                default:
                    break;
            }
            return jjStartNfa_10(1, active0);
        }
        private int jjStartNfaWithStates_10(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_10(state, pos + 1);
        }
        private int jjMoveNfa_10(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 15;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x2400L & (ulong)l) != 0L)
                                {
                                    if (kind > 25)
                                        kind = 25;
                                }
                                else if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(12, 13);
                                }
                                else if (curChar == '#')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                if (curChar == 13)
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 0:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 1;
                                break;
                            case 1:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            case 2:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 0;
                                break;
                            case 4:
                                if ((0x2400L & (ulong)l) != 0L && kind > 25)
                                    kind = 25;
                                break;
                            case 5:
                                if (curChar == 10 && kind > 25)
                                    kind = 25;
                                break;
                            case 6:
                                if (curChar == 13)
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 9:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 11:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(12, 13);
                                break;
                            case 13:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 14:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(12, 13);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '\\')
                                    jjCheckNAddStates(165, 168);
                                break;
                            case 1:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            case 8:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(8, 9);
                                break;
                            case 10:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(10, 11);
                                break;
                            case 12:
                                if (curChar == '\\')
                                    jjAddStates(169, 170);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x3a0000L) != 0L)
                        return 33;
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        return 13;
                    }
                    return -1;
                case 1:
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        jjmatchedPos = 1;
                        return 13;
                    }
                    if ((active0 & 0x80000L) != 0L)
                        return 31;
                    return -1;
                case 2:
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        jjmatchedPos = 2;
                        return 13;
                    }
                    return -1;
                case 3:
                    if ((active0 & 0x200000000L) != 0L)
                        return 13;
                    if ((active0 & 0x400000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        jjmatchedPos = 3;
                        return 13;
                    }
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_0(int pos, long active0, long active1)
        {
            return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_0()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_0(0x2a0000L);
                case '[':
                    return jjStopAtPos(0, 1);
                case 'f':
                    return jjMoveStringLiteralDfa1_0(0x400000000L);
                case 't':
                    return jjMoveStringLiteralDfa1_0(0x200000000L);
                case '{':
                    return jjStopAtPos(0, 68);
                case '}':
                    return jjStopAtPos(0, 69);
                default:
                    return jjMoveNfa_0(12, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_0(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_0(0, active0, 0L);
                return 1;
            }
            switch (curChar)
            {
                case '#':
                    if ((active0 & 0x200000L) != 0L)
                        return jjStopAtPos(1, 21);
                    break;
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_0(1, 19, 31);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
                case 'a':
                    return jjMoveStringLiteralDfa2_0(active0, 0x400000000L);
                case 'r':
                    return jjMoveStringLiteralDfa2_0(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_0(0, active0, 0L);
        }
        private int jjMoveStringLiteralDfa2_0(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_0(0, old0, 0L);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_0(1, active0, 0L);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                case 'l':
                    return jjMoveStringLiteralDfa3_0(active0, 0x400000000L);
                case 'u':
                    return jjMoveStringLiteralDfa3_0(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_0(1, active0, 0L);
        }
        private int jjMoveStringLiteralDfa3_0(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_0(1, old0, 0L);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_0(2, active0, 0L);
                return 3;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x200000000L) != 0L)
                        return jjStartNfaWithStates_0(3, 33, 13);
                    break;
                case 's':
                    return jjMoveStringLiteralDfa4_0(active0, 0x400000000L);
                default:
                    break;
            }
            return jjStartNfa_0(2, active0, 0L);
        }
        private int jjMoveStringLiteralDfa4_0(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_0(2, old0, 0L);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_0(3, active0, 0L);
                return 4;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x400000000L) != 0L)
                        return jjStartNfaWithStates_0(4, 34, 13);
                    break;
                default:
                    break;
            }
            return jjStartNfa_0(3, active0, 0L);
        }
        private int jjStartNfaWithStates_0(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_0(state, pos + 1);
        }
        private int jjMoveNfa_0(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 34;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 12:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(0, 1);
                                else if (curChar == '#')
                                    jjCheckNAddStates(171, 173);
                                else if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(27, 28);
                                }
                                else if (curChar == 46)
                                    jjstateSet[jjnewStateCnt++] = 15;
                                if (curChar == '$')
                                    jjCheckNAddStates(174, 177);
                                break;
                            case 33:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 31;
                                break;
                            case 0:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(0, 1);
                                break;
                            case 1:
                                if (curChar == '#')
                                    jjCheckNAddTwoStates(6, 11);
                                break;
                            case 3:
                                if (curChar == 32)
                                    jjAddStates(112, 113);
                                break;
                            case 4:
                                if (curChar == '(' && kind > 14)
                                    kind = 14;
                                break;
                            case 13:
                                if ((0x3ff200000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 66)
                                    kind = 66;
                                jjstateSet[jjnewStateCnt++] = 13;
                                break;
                            case 14:
                                if (curChar == 46)
                                    jjstateSet[jjnewStateCnt++] = 15;
                                break;
                            case 16:
                                if (curChar == '$')
                                    jjCheckNAddStates(174, 177);
                                break;
                            case 18:
                            case 19:
                                if (curChar == '!')
                                    jjCheckNAdd(17);
                                break;
                            case 21:
                                if (curChar == 46 && kind > 72)
                                    kind = 72;
                                break;
                            case 24:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 26:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(27, 28);
                                break;
                            case 28:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 29:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(27, 28);
                                break;
                            case 30:
                                if (curChar == '#')
                                    jjCheckNAddStates(171, 173);
                                break;
                            case 31:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 32;
                                break;
                            case 32:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 12:
                                if ((0x7fffffe87fffffeL & (ulong)l) != 0L)
                                {
                                    if (kind > 66)
                                        kind = 66;
                                    jjCheckNAdd(13);
                                }
                                else if (curChar == '\\')
                                    jjCheckNAddStates(178, 181);
                                break;
                            case 33:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 10;
                                else if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 2:
                                if (curChar == 't')
                                    jjCheckNAddTwoStates(3, 4);
                                break;
                            case 5:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 6:
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 7:
                                if (curChar == '}')
                                    jjCheckNAddTwoStates(3, 4);
                                break;
                            case 8:
                                if (curChar == 't')
                                    jjstateSet[jjnewStateCnt++] = 7;
                                break;
                            case 9:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 8;
                                break;
                            case 10:
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 9;
                                break;
                            case 11:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 10;
                                break;
                            case 13:
                                if ((0x7fffffe87fffffeL & (ulong)l) == 0L)
                                    break;
                                if (kind > 66)
                                    kind = 66;
                                jjCheckNAdd(13);
                                break;
                            case 15:
                                if ((0x7fffffe07fffffeL & (ulong)l) != 0L && kind > 67)
                                    kind = 67;
                                break;
                            case 17:
                                if (curChar == '[' && kind > 72)
                                    kind = 72;
                                break;
                            case 20:
                                if (curChar == '\\')
                                    jjstateSet[jjnewStateCnt++] = 19;
                                break;
                            case 22:
                                if (curChar == '\\')
                                    jjCheckNAddStates(178, 181);
                                break;
                            case 23:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(23, 24);
                                break;
                            case 25:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(25, 26);
                                break;
                            case 27:
                                if (curChar == '\\')
                                    jjAddStates(182, 183);
                                break;
                            case 32:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 32:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                i = jjnewStateCnt;
                jjnewStateCnt = startsAt;
                startsAt = 34 - jjnewStateCnt;
                if (i == startsAt)
                    return curPos;
                try
                {
                    curChar = input_stream.ReadChar();
                }
                catch (IOException e)
                {
                    return curPos;
                }
            }
        }
        private int jjStopStringLiteralDfa_4(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x1a0000L) != 0L)
                        return 52;
                    if ((active0 & 0x40L) != 0L)
                        return 74;
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        return 40;
                    }
                    return -1;
                case 1:
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        jjmatchedPos = 1;
                        return 40;
                    }
                    if ((active0 & 0x80000L) != 0L)
                        return 50;
                    return -1;
                case 2:
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        jjmatchedPos = 2;
                        return 40;
                    }
                    return -1;
                case 3:
                    if ((active0 & 0x200000000L) != 0L)
                        return 40;
                    if ((active0 & 0x400000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        jjmatchedPos = 3;
                        return 40;
                    }
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_4(int pos, long active0)
        {
            return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_4()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_4(0xa0000L);
                case ')':
                    return jjStopAtPos(0, 12);
                case ',':
                    return jjStopAtPos(0, 5);
                case '.':
                    return jjMoveStringLiteralDfa1_4(0x40L);
                case ':':
                    return jjStopAtPos(0, 7);
                case '[':
                    return jjStopAtPos(0, 3);
                case ']':
                    return jjStopAtPos(0, 4);
                case 'f':
                    return jjMoveStringLiteralDfa1_4(0x400000000L);
                case 't':
                    return jjMoveStringLiteralDfa1_4(0x200000000L);
                case '{':
                    return jjStopAtPos(0, 8);
                case '}':
                    return jjStopAtPos(0, 9);
                default:
                    return jjMoveNfa_4(13, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_4(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_4(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_4(1, 19, 50);
                    break;
                case '.':
                    if ((active0 & 0x40L) != 0L)
                        return jjStopAtPos(1, 6);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_4(active0, 0x20000L);
                case 'a':
                    return jjMoveStringLiteralDfa2_4(active0, 0x400000000L);
                case 'r':
                    return jjMoveStringLiteralDfa2_4(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_4(0, active0);
        }
        private int jjMoveStringLiteralDfa2_4(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_4(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_4(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                case 'l':
                    return jjMoveStringLiteralDfa3_4(active0, 0x400000000L);
                case 'u':
                    return jjMoveStringLiteralDfa3_4(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_4(1, active0);
        }
        private int jjMoveStringLiteralDfa3_4(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_4(1, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_4(2, active0);
                return 3;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x200000000L) != 0L)
                        return jjStartNfaWithStates_4(3, 33, 40);
                    break;
                case 's':
                    return jjMoveStringLiteralDfa4_4(active0, 0x400000000L);
                default:
                    break;
            }
            return jjStartNfa_4(2, active0);
        }
        private int jjMoveStringLiteralDfa4_4(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_4(2, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_4(3, active0);
                return 4;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x400000000L) != 0L)
                        return jjStartNfaWithStates_4(4, 34, 40);
                    break;
                default:
                    break;
            }
            return jjStartNfa_4(3, active0);
        }
        private int jjStartNfaWithStates_4(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_4(state, pos + 1);
        }
        private int jjMoveNfa_4(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 75;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 52:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 50;
                                break;
                            case 74:
                            case 64:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(64, 65);
                                break;
                            case 13:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                {
                                    if (kind > 56)
                                        kind = 56;
                                    jjCheckNAddStates(184, 189);
                                }
                                else if ((0x100002600L & (ulong)l) != 0L)
                                {
                                    if (kind > 31)
                                        kind = 31;
                                    jjCheckNAdd(12);
                                }
                                else if (curChar == 46)
                                    jjCheckNAddTwoStates(64, 74);
                                else if (curChar == 45)
                                    jjCheckNAddStates(190, 193);
                                else if (curChar == '#')
                                    jjCheckNAddStates(194, 196);
                                else if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(46, 47);
                                }
                                else if (curChar == 39)
                                    jjCheckNAddStates(197, 200);
                                else if (curChar == 34)
                                    jjCheckNAddStates(201, 204);
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(0, 1);
                                break;
                            case 0:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(0, 1);
                                break;
                            case 1:
                                if (curChar == '#')
                                    jjCheckNAddTwoStates(6, 11);
                                break;
                            case 3:
                                if (curChar == 32)
                                    jjAddStates(112, 113);
                                break;
                            case 4:
                                if (curChar == '(' && kind > 14)
                                    kind = 14;
                                break;
                            case 12:
                                if ((0x100002600L & (ulong)l) == 0L)
                                    break;
                                if (kind > 31)
                                    kind = 31;
                                jjCheckNAdd(12);
                                break;
                            case 14:
                                if ((0xfffffffbffffffffL & (ulong)l) != 0L)
                                    jjCheckNAddStates(201, 204);
                                break;
                            case 15:
                                if (curChar == 34)
                                    jjCheckNAddStates(201, 204);
                                break;
                            case 16:
                                if (curChar == 34)
                                    jjstateSet[jjnewStateCnt++] = 15;
                                break;
                            case 17:
                                if (curChar == 34 && kind > 32)
                                    kind = 32;
                                break;
                            case 20:
                                if ((0xff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(205, 209);
                                break;
                            case 21:
                                if ((0xff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(201, 204);
                                break;
                            case 22:
                                if ((0xf000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 23;
                                break;
                            case 23:
                                if ((0xff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(21);
                                break;
                            case 25:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 26;
                                break;
                            case 26:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 27;
                                break;
                            case 27:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 28;
                                break;
                            case 28:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(201, 204);
                                break;
                            case 29:
                                if (curChar == 32)
                                    jjAddStates(210, 211);
                                break;
                            case 30:
                                if (curChar == 10)
                                    jjCheckNAddStates(201, 204);
                                break;
                            case 31:
                            case 33:
                                if (curChar == 39)
                                    jjCheckNAddStates(197, 200);
                                break;
                            case 32:
                                if ((0xffffff7fffffffffL & (ulong)l) != 0L)
                                    jjCheckNAddStates(197, 200);
                                break;
                            case 34:
                                if (curChar == 39)
                                    jjstateSet[jjnewStateCnt++] = 33;
                                break;
                            case 36:
                                if (curChar == 32)
                                    jjAddStates(212, 213);
                                break;
                            case 37:
                                if (curChar == 10)
                                    jjCheckNAddStates(197, 200);
                                break;
                            case 38:
                                if (curChar == 39 && kind > 32)
                                    kind = 32;
                                break;
                            case '(':
                                if ((0x3ff200000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 66)
                                    kind = 66;
                                jjstateSet[jjnewStateCnt++] = 40;
                                break;
                            case 43:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 45:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(46, 47);
                                break;
                            case 47:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 48:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(46, 47);
                                break;
                            case 49:
                                if (curChar == '#')
                                    jjCheckNAddStates(194, 196);
                                break;
                            case 50:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 51;
                                break;
                            case 51:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            case 53:
                                if (curChar == 45)
                                    jjCheckNAddStates(190, 193);
                                break;
                            case 54:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 56)
                                    kind = 56;
                                jjCheckNAddTwoStates(54, 56);
                                break;
                            case 55:
                                if (curChar == 46 && kind > 56)
                                    kind = 56;
                                break;
                            case 56:
                                if (curChar == 46)
                                    jjstateSet[jjnewStateCnt++] = 55;
                                break;
                            case 57:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(57, 58);
                                break;
                            case ':':
                                if (curChar != 46)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(59, 60);
                                break;
                            case 59:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAddTwoStates(59, 60);
                                break;
                            case 61:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(62);
                                break;
                            case 62:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(62);
                                break;
                            case 63:
                                if (curChar == 46)
                                    jjCheckNAdd(64);
                                break;
                            case 66:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(67);
                                break;
                            case 67:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(67);
                                break;
                            case 68:
                                if ((0x3ff000000000000L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(68, 69);
                                break;
                            case 70:
                                if ((0x280000000000L & (ulong)l) != 0L)
                                    jjCheckNAdd(71);
                                break;
                            case 71:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 57)
                                    kind = 57;
                                jjCheckNAdd(71);
                                break;
                            case 72:
                                if ((0x3ff000000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 56)
                                    kind = 56;
                                jjCheckNAddStates(184, 189);
                                break;
                            case 73:
                                if (curChar == 46)
                                    jjCheckNAddTwoStates(64, 74);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 52:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 10;
                                else if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 74:
                                if ((0x7fffffe07fffffeL & (ulong)l) != 0L && kind > 67)
                                    kind = 67;
                                break;
                            case 13:
                                if ((0x7fffffe87fffffeL & (ulong)l) != 0L)
                                {
                                    if (kind > 66)
                                        kind = 66;
                                    jjCheckNAdd(40);
                                }
                                else if (curChar == '\\')
                                    jjCheckNAddStates(214, 217);
                                break;
                            case 2:
                                if (curChar == 't')
                                    jjCheckNAddTwoStates(3, 4);
                                break;
                            case 5:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 6:
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 7:
                                if (curChar == '}')
                                    jjCheckNAddTwoStates(3, 4);
                                break;
                            case 8:
                                if (curChar == 't')
                                    jjstateSet[jjnewStateCnt++] = 7;
                                break;
                            case 9:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 8;
                                break;
                            case 10:
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 9;
                                break;
                            case 11:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 10;
                                break;
                            case 14:
                                jjCheckNAddStates(201, 204);
                                break;
                            case 18:
                                if (curChar == '\\')
                                    jjAddStates(218, 223);
                                break;
                            case 19:
                                if ((0x14404400000000L & (ulong)l) != 0L)
                                    jjCheckNAddStates(201, 204);
                                break;
                            case 24:
                                if (curChar == 117)
                                    jjstateSet[jjnewStateCnt++] = 25;
                                break;
                            case 25:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 26;
                                break;
                            case 26:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 27;
                                break;
                            case 27:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjstateSet[jjnewStateCnt++] = 28;
                                break;
                            case 28:
                                if ((0x7e0000007eL & (ulong)l) != 0L)
                                    jjCheckNAddStates(201, 204);
                                break;
                            case 32:
                                jjAddStates(197, 200);
                                break;
                            case '#':
                                if (curChar == '\\')
                                    jjAddStates(212, 213);
                                break;
                            case 39:
                            case '(':
                                if ((0x7fffffe87fffffeL & (ulong)l) == 0L)
                                    break;
                                if (kind > 66)
                                    kind = 66;
                                jjCheckNAdd(40);
                                break;
                            case ')':
                                if (curChar == '\\')
                                    jjCheckNAddStates(214, 217);
                                break;
                            case '*':
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(42, 43);
                                break;
                            case ',':
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(44, 45);
                                break;
                            case '.':
                                if (curChar == '\\')
                                    jjAddStates(224, 225);
                                break;
                            case 51:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            case 60:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(226, 227);
                                break;
                            case 65:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(228, 229);
                                break;
                            case 69:
                                if ((0x2000000020L & (ulong)l) != 0L)
                                    jjAddStates(30, 31);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 14:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                    jjAddStates(201, 204);
                                break;
                            case 32:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                    jjAddStates(197, 200);
                                break;
                            case 51:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        return 13;
                    }
                    if ((active0 & 0x1a0000L) != 0L)
                        return 27;
                    return -1;
                case 1:
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        jjmatchedPos = 1;
                        return 13;
                    }
                    if ((active0 & 0x80000L) != 0L)
                        return 25;
                    return -1;
                case 2:
                    if ((active0 & 0x600000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        jjmatchedPos = 2;
                        return 13;
                    }
                    return -1;
                case 3:
                    if ((active0 & 0x200000000L) != 0L)
                        return 13;
                    if ((active0 & 0x400000000L) != 0L)
                    {
                        jjmatchedKind = 66;
                        jjmatchedPos = 3;
                        return 13;
                    }
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_1(int pos, long active0, long active1)
        {
            return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_1()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_1(0xa0000L);
                case '(':
                    return jjStopAtPos(0, 10);
                case '[':
                    return jjStopAtPos(0, 1);
                case 'f':
                    return jjMoveStringLiteralDfa1_1(0x400000000L);
                case 't':
                    return jjMoveStringLiteralDfa1_1(0x200000000L);
                case '{':
                    return jjStopAtPos(0, 68);
                case '}':
                    return jjStopAtPos(0, 69);
                default:
                    return jjMoveNfa_1(12, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_1(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_1(0, active0, 0L);
                return 1;
            }
            switch (curChar)
            {
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_1(1, 19, 25);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_1(active0, 0x20000L);
                case 'a':
                    return jjMoveStringLiteralDfa2_1(active0, 0x400000000L);
                case 'r':
                    return jjMoveStringLiteralDfa2_1(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_1(0, active0, 0L);
        }
        private int jjMoveStringLiteralDfa2_1(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_1(0, old0, 0L);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_1(1, active0, 0L);
                return 2;
            }
            switch (curChar)
            {
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                case 'l':
                    return jjMoveStringLiteralDfa3_1(active0, 0x400000000L);
                case 'u':
                    return jjMoveStringLiteralDfa3_1(active0, 0x200000000L);
                default:
                    break;
            }
            return jjStartNfa_1(1, active0, 0L);
        }
        private int jjMoveStringLiteralDfa3_1(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_1(1, old0, 0L);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_1(2, active0, 0L);
                return 3;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x200000000L) != 0L)
                        return jjStartNfaWithStates_1(3, 33, 13);
                    break;
                case 's':
                    return jjMoveStringLiteralDfa4_1(active0, 0x400000000L);
                default:
                    break;
            }
            return jjStartNfa_1(2, active0, 0L);
        }
        private int jjMoveStringLiteralDfa4_1(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_1(2, old0, 0L);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_1(3, active0, 0L);
                return 4;
            }
            switch (curChar)
            {
                case 'e':
                    if ((active0 & 0x400000000L) != 0L)
                        return jjStartNfaWithStates_1(4, 34, 13);
                    break;
                default:
                    break;
            }
            return jjStartNfa_1(3, active0, 0L);
        }
        private int jjStartNfaWithStates_1(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_1(state, pos + 1);
        }
        private int jjMoveNfa_1(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 28;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 12:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(0, 1);
                                else if (curChar == '#')
                                    jjCheckNAddStates(230, 232);
                                else if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(21, 22);
                                }
                                else if (curChar == 46)
                                    jjstateSet[jjnewStateCnt++] = 15;
                                break;
                            case 27:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 25;
                                break;
                            case 0:
                                if ((0x100000200L & (ulong)l) != 0L)
                                    jjCheckNAddTwoStates(0, 1);
                                break;
                            case 1:
                                if (curChar == '#')
                                    jjCheckNAddTwoStates(6, 11);
                                break;
                            case 3:
                                if (curChar == 32)
                                    jjAddStates(112, 113);
                                break;
                            case 4:
                                if (curChar == '(' && kind > 14)
                                    kind = 14;
                                break;
                            case 13:
                                if ((0x3ff200000000000L & (ulong)l) == 0L)
                                    break;
                                if (kind > 66)
                                    kind = 66;
                                jjstateSet[jjnewStateCnt++] = 13;
                                break;
                            case 14:
                                if (curChar == 46)
                                    jjstateSet[jjnewStateCnt++] = 15;
                                break;
                            case 18:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 20:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(21, 22);
                                break;
                            case 22:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 23:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(21, 22);
                                break;
                            case 24:
                                if (curChar == '#')
                                    jjCheckNAddStates(230, 232);
                                break;
                            case 25:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 26;
                                break;
                            case 26:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 12:
                                if ((0x7fffffe87fffffeL & (ulong)l) != 0L)
                                {
                                    if (kind > 66)
                                        kind = 66;
                                    jjCheckNAdd(13);
                                }
                                else if (curChar == '\\')
                                    jjCheckNAddStates(233, 236);
                                break;
                            case 27:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 10;
                                else if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 2:
                                if (curChar == 't')
                                    jjCheckNAddTwoStates(3, 4);
                                break;
                            case 5:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 6:
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 7:
                                if (curChar == '}')
                                    jjCheckNAddTwoStates(3, 4);
                                break;
                            case 8:
                                if (curChar == 't')
                                    jjstateSet[jjnewStateCnt++] = 7;
                                break;
                            case 9:
                                if (curChar == 'e')
                                    jjstateSet[jjnewStateCnt++] = 8;
                                break;
                            case 10:
                                if (curChar == 's')
                                    jjstateSet[jjnewStateCnt++] = 9;
                                break;
                            case 11:
                                if (curChar == '{')
                                    jjstateSet[jjnewStateCnt++] = 10;
                                break;
                            case 13:
                                if ((0x7fffffe87fffffeL & (ulong)l) == 0L)
                                    break;
                                if (kind > 66)
                                    kind = 66;
                                jjCheckNAdd(13);
                                break;
                            case 15:
                                if ((0x7fffffe07fffffeL & (ulong)l) != 0L && kind > 67)
                                    kind = 67;
                                break;
                            case 16:
                                if (curChar == '\\')
                                    jjCheckNAddStates(233, 236);
                                break;
                            case 17:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(17, 18);
                                break;
                            case 19:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(19, 20);
                                break;
                            case 21:
                                if (curChar == '\\')
                                    jjAddStates(143, 144);
                                break;
                            case 26:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 26:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 28 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        private int jjStopStringLiteralDfa_7(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x1a0000L) != 0L)
                        return 2;
                    return -1;
                case 1:
                    if ((active0 & 0x80000L) != 0L)
                        return 0;
                    return -1;
                default:
                    return -1;
            }
        }
        private int jjStartNfa_7(int pos, long active0)
        {
            return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
        }
        private int jjMoveStringLiteralDfa0_7()
        {
            switch (curChar)
            {
                case '#':
                    jjmatchedKind = 20;
                    return jjMoveStringLiteralDfa1_7(0xa0000L);
                case ']':
                    return jjMoveStringLiteralDfa1_7(0x10000000L);
                default:
                    return jjMoveNfa_7(3, 0);
            }
        }
        private int jjMoveStringLiteralDfa1_7(long active0)
        {
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_7(0, active0);
                return 1;
            }
            switch (curChar)
            {
                case '*':
                    if ((active0 & 0x80000L) != 0L)
                        return jjStartNfaWithStates_7(1, 19, 0);
                    break;
                case '[':
                    return jjMoveStringLiteralDfa2_7(active0, 0x20000L);
                case ']':
                    return jjMoveStringLiteralDfa2_7(active0, 0x10000000L);
                default:
                    break;
            }
            return jjStartNfa_7(0, active0);
        }
        private int jjMoveStringLiteralDfa2_7(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
                return jjStartNfa_7(0, old0);
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e)
            {
                jjStopStringLiteralDfa_7(1, active0);
                return 2;
            }
            switch (curChar)
            {
                case '#':
                    if ((active0 & 0x10000000L) != 0L)
                        return jjStopAtPos(2, 28);
                    break;
                case '[':
                    if ((active0 & 0x20000L) != 0L)
                        return jjStopAtPos(2, 17);
                    break;
                default:
                    break;
            }
            return jjStartNfa_7(1, active0);
        }
        private int jjStartNfaWithStates_7(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            try { curChar = input_stream.ReadChar(); }
            catch (IOException e) { return pos + 1; }
            return jjMoveNfa_7(state, pos + 1);
        }
        private int jjMoveNfa_7(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 12;
            int i = 1;
            jjstateSet[0] = startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                    ReInitRounds();
                if (curChar < 64)
                {
                    long l = 1L << curChar;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '$')
                                {
                                    if (kind > 15)
                                        kind = 15;
                                    jjCheckNAddTwoStates(9, 10);
                                }
                                else if (curChar == '#')
                                    jjstateSet[jjnewStateCnt++] = 2;
                                break;
                            case 0:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 1;
                                break;
                            case 1:
                                if ((0xfffffff7ffffffffL & (ulong)l) != 0L && kind > 18)
                                    kind = 18;
                                break;
                            case 2:
                                if (curChar == 42)
                                    jjstateSet[jjnewStateCnt++] = 0;
                                break;
                            case 6:
                                if (curChar == '$' && kind > 15)
                                    kind = 15;
                                break;
                            case 8:
                                if (curChar == '$')
                                    jjCheckNAddTwoStates(9, 10);
                                break;
                            case 10:
                                if (curChar == '!' && kind > 16)
                                    kind = 16;
                                break;
                            case 11:
                                if (curChar != 36)
                                    break;
                                if (kind > 15)
                                    kind = 15;
                                jjCheckNAddTwoStates(9, 10);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else if (curChar < 128)
                {
                    long l = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (curChar == '\\')
                                    jjCheckNAddStates(99, 102);
                                break;
                            case 1:
                                if (kind > 18)
                                    kind = 18;
                                break;
                            case 5:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(5, 6);
                                break;
                            case 7:
                                if (curChar == '\\')
                                    jjCheckNAddTwoStates(7, 8);
                                break;
                            case 9:
                                if (curChar == '\\')
                                    jjAddStates(91, 92);
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (int)(curChar >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (curChar & 0xff) >> 6;
                    long l2 = 1L << (curChar & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
                                    kind = 18;
                                break;
                            default: break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
                    return curPos;
                try { curChar = input_stream.ReadChar(); }
                catch (IOException e) { return curPos; }
            }
        }
        static int[] jjnextStates = {
   91, 93, 94, 95, 100, 101, 91, 94, 61, 100, 29, 31, 32, 35, 11, 13, 
   14, 15, 1, 2, 4, 11, 18, 13, 14, 15, 26, 27, 33, 34, 70, 71, 
   73, 74, 75, 76, 87, 89, 84, 85, 81, 82, 16, 17, 19, 21, 26, 27, 
   64, 65, 77, 78, 98, 99, 102, 103, 69, 71, 72, 73, 78, 79, 69, 72, 
   6, 78, 15, 16, 27, 28, 30, 38, 39, 41, 46, 28, 47, 62, 39, 63, 
   50, 53, 60, 67, 18, 19, 20, 21, 31, 36, 43, 9, 10, 22, 23, 76, 
   77, 80, 81, 5, 6, 7, 8, 6, 11, 39, 14, 15, 17, 18, 22, 24, 
   3, 4, 20, 21, 29, 30, 31, 32, 45, 47, 48, 49, 54, 55, 45, 48, 
   31, 54, 24, 26, 27, 30, 6, 8, 9, 10, 6, 13, 8, 9, 10, 21, 
   22, 28, 29, 37, 38, 39, 40, 11, 12, 14, 16, 21, 22, 34, 35, 41, 
   42, 52, 53, 56, 57, 8, 9, 10, 11, 12, 13, 6, 11, 33, 17, 18, 
   20, 21, 23, 24, 25, 26, 27, 28, 54, 56, 57, 58, 68, 69, 54, 57, 
   63, 68, 6, 11, 52, 32, 34, 35, 38, 14, 16, 17, 18, 14, 21, 16, 
   17, 18, 29, 30, 36, 37, 42, 43, 44, 45, 19, 20, 22, 24, 29, 30, 
   46, 47, 61, 62, 66, 67, 6, 11, 27, 17, 18, 19, 20, 
};
        private static bool jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
        {
            switch (hiByte)
            {
                case 0:
                    return ((jjbitVec2[i2] & (ulong)l2) != 0L);
                default:
                    if ((jjbitVec0[i1] & (ulong)l1) != 0L)
                        return true;
                    return false;
            }
        }

        /** Token literal values. */
        public static String[] jjstrLiteralImages = {
null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
null, null, null, null, };

        /** Lexer state names. */
        public static String[] lexStateNames = {
   "REFERENCE",
   "REFMODIFIER",
   "REFINDEX",
   "DIRECTIVE",
   "REFMOD2",
   "DEFAULT",
   "REFMOD",
   "IN_TEXTBLOCK",
   "IN_MULTI_LINE_COMMENT",
   "IN_FORMAL_COMMENT",
   "IN_SINGLE_LINE_COMMENT",
   "PRE_DIRECTIVE",
};

        /** Lex State array. */
        public static int[] jjnewLexState = {
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
};
        static long[] jjtoToken = {
   0x637fffff9fe07fffL, 0x13cL, 
};
        static long[] jjtoSkip = {
   0x20000000L, 0xc0L, 
};
        static long[] jjtoSpecial = {
   0x0L, 0xc0L, 
};
        static long[] jjtoMore = {
   0x401f8000L, 0x0L, 
};
        protected CharStream input_stream;
        private uint[] jjrounds = new uint[105];
        private int[] jjstateSet = new int[210];
        private StringBuilder jjimage = new StringBuilder();
        private StringBuilder image = null;
        private int jjimageLen;
        private int lengthOfMatch;
        protected char curChar;
        /** Constructor. */
        public ParserTokenManager(CharStream stream)
        {
            this.image = jjimage;
            input_stream = stream;
        }

        /** Constructor. */
        public ParserTokenManager(CharStream stream, int lexState)
            : this(stream)
        {
            SwitchTo(lexState);
        }

        /** Reinitialise parser. */
        public void ReInit(CharStream stream)
        {
            jjmatchedPos = jjnewStateCnt = 0;
            curLexState = defaultLexState;
            input_stream = stream;
            ReInitRounds();
        }
        private void ReInitRounds()
        {
            int i;
            jjround = 0x80000001;
            for (i = 105; i-- > 0; )
                jjrounds[i] = 0x80000000;
        }

        /** Reinitialise parser. */
        public void ReInit(CharStream stream, int lexState)
        {
            ReInit(stream);
            SwitchTo(lexState);
        }

        /** Switch to specified lex state. */
        public void SwitchTo(int lexState)
        {
            if (lexState >= 12 || lexState < 0)
                throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
            else
                curLexState = lexState;
        }

        protected Token jjFillToken()
        {
            Token t;
            String curTokenImage;
            int beginLine;
            int endLine;
            int beginColumn;
            int endColumn;
            String im = jjstrLiteralImages[jjmatchedKind];
            curTokenImage = (im == null) ? input_stream.GetImage() : im;
            beginLine = input_stream.BeginLine;
            beginColumn = input_stream.BeginColumn;
            endLine = input_stream.EndLine;
            endColumn = input_stream.EndColumn;
            t = Token.newToken(jjmatchedKind);
            t.kind = jjmatchedKind;
            t.image = curTokenImage;

            t.beginLine = beginLine;
            t.endLine = endLine;
            t.beginColumn = beginColumn;
            t.endColumn = endColumn;

            return t;
        }

        int curLexState = 5;
        int defaultLexState = 5;
        int jjnewStateCnt;
        uint jjround;
        int jjmatchedPos;
        int jjmatchedKind;

        /** Get the next Token. */
        public Token GetNextToken()
        {
            Token specialToken = null;
            Token matchedToken;
            int curPos = 0;

            for (; ; )
            {
                try
                {
                    curChar = input_stream.BeginToken();
                }
                catch (IOException e)
                {
                    jjmatchedKind = 0;
                    matchedToken = jjFillToken();
                    matchedToken.specialToken = specialToken;
                    return matchedToken;
                }
                image = jjimage;
                image.Clear();
                image.Capacity = 0;
                jjimageLen = 0;

                for (; ; )
                {
                    switch (curLexState)
                    {
                        case 0:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_0();
                            if (jjmatchedPos == 0 && jjmatchedKind > 70)
                            {
                                jjmatchedKind = 70;
                            }
                            break;
                        case 1:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_1();
                            if (jjmatchedPos == 0 && jjmatchedKind > 70)
                            {
                                jjmatchedKind = 70;
                            }
                            break;
                        case 2:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_2();
                            break;
                        case 3:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_3();
                            break;
                        case 4:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_4();
                            break;
                        case 5:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_5();
                            break;
                        case 6:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_6();
                            if (jjmatchedPos == 0 && jjmatchedKind > 70)
                            {
                                jjmatchedKind = 70;
                            }
                            break;
                        case 7:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_7();
                            if (jjmatchedPos == 0 && jjmatchedKind > 30)
                            {
                                jjmatchedKind = 30;
                            }
                            break;
                        case 8:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_8();
                            if (jjmatchedPos == 0 && jjmatchedKind > 29)
                            {
                                jjmatchedKind = 29;
                            }
                            break;
                        case 9:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_9();
                            if (jjmatchedPos == 0 && jjmatchedKind > 29)
                            {
                                jjmatchedKind = 29;
                            }
                            break;
                        case 10:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_10();
                            if (jjmatchedPos == 0 && jjmatchedKind > 29)
                            {
                                jjmatchedKind = 29;
                            }
                            break;
                        case 11:
                            jjmatchedKind = 0x7fffffff;
                            jjmatchedPos = 0;
                            curPos = jjMoveStringLiteralDfa0_11();
                            if (jjmatchedPos == 0 && jjmatchedKind > 71)
                            {
                                jjmatchedKind = 71;
                            }
                            break;
                    }
                    if (jjmatchedKind != 0x7fffffff)
                    {
                        if (jjmatchedPos + 1 < curPos)
                            input_stream.Backup(curPos - jjmatchedPos - 1);
                        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 63))) != 0L)
                        {
                            matchedToken = jjFillToken();
                            matchedToken.specialToken = specialToken;
                            TokenLexicalActions(matchedToken);
                            if (jjnewLexState[jjmatchedKind] != -1)
                                curLexState = jjnewLexState[jjmatchedKind];
                            return matchedToken;
                        }
                        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 63))) != 0L)
                        {
                            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 63))) != 0L)
                            {
                                matchedToken = jjFillToken();
                                if (specialToken == null)
                                    specialToken = matchedToken;
                                else
                                {
                                    matchedToken.specialToken = specialToken;
                                    specialToken = (specialToken.next = matchedToken);
                                }
                                SkipLexicalActions(matchedToken);
                            }
                            else
                                SkipLexicalActions(null);
                            if (jjnewLexState[jjmatchedKind] != -1)
                                curLexState = jjnewLexState[jjmatchedKind];
                            goto EOFLoop;
                        }
                        MoreLexicalActions();
                        if (jjnewLexState[jjmatchedKind] != -1)
                            curLexState = jjnewLexState[jjmatchedKind];
                        curPos = 0;
                        jjmatchedKind = 0x7fffffff;
                        try
                        {
                            curChar = input_stream.ReadChar();
                            continue;
                        }
                        catch (IOException e1) { }
                    }
                    int error_line = input_stream.EndLine;
                    int error_column = input_stream.EndColumn;
                    String error_after = null;
                    bool EOFSeen = false;
                    try { input_stream.ReadChar(); input_stream.Backup(1); }
                    catch (IOException e1)
                    {
                        EOFSeen = true;
                        error_after = curPos <= 1 ? "" : input_stream.GetImage();
                        if (curChar == '\n' || curChar == '\r')
                        {
                            error_line++;
                            error_column = 0;
                        }
                        else
                            error_column++;
                    }
                    if (!EOFSeen)
                    {
                        input_stream.Backup(1);
                        error_after = curPos <= 1 ? "" : input_stream.GetImage();
                    }
                    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
                }
            EOFLoop:
                ;
            }
        }

        void SkipLexicalActions(Token matchedToken)
        {
            switch (jjmatchedKind)
            {
                case 70:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    /*
                     * push every terminator character back into the stream
                     */

                    input_stream.Backup(1);

                    inReference = false;

                    if (debugPrint)
                        Console.Write("REF_TERM :");

                    stateStackPop();
                    break;
                case 71:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    if (debugPrint)
                        Console.Write("DIRECTIVE_TERM :");

                    input_stream.Backup(1);
                    inDirective = false;
                    stateStackPop();
                    break;
                default:
                    break;
            }
        }
        void MoreLexicalActions()
        {
            jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
            switch (jjmatchedKind)
            {
                case 15:
                    image.Append(input_stream.GetSuffix(jjimageLen));
                    jjimageLen = 0;
                    if (!inComment)
                    {
                        /*
                         * if we find ourselves in REFERENCE, we need to pop down
                         * to end the previous ref
                         */

                        if (curLexState == REFERENCE)
                        {
                            inReference = false;
                            stateStackPop();
                        }

                        inReference = true;

                        if (debugPrint)
                            Console.Write("$  : going to " + REFERENCE);

                        stateStackPush();
                        SwitchTo(REFERENCE);
                    }
                    break;
                case 16:
                    image.Append(input_stream.GetSuffix(jjimageLen));
                    jjimageLen = 0;
                    if (!inComment)
                    {
                        /*
                         * if we find ourselves in REFERENCE, we need to pop down
                         * to end the previous ref
                         */

                        if (curLexState == REFERENCE)
                        {
                            inReference = false;
                            stateStackPop();
                        }

                        inReference = true;

                        if (debugPrint)
                            Console.Write("$!  : going to " + REFERENCE);

                        stateStackPush();
                        SwitchTo(REFERENCE);
                    }
                    break;
                case 17:
                    image.Append(input_stream.GetSuffix(jjimageLen));
                    jjimageLen = 0;
                    if (!inComment)
                    {
                        inComment = true;
                        stateStackPush();
                        SwitchTo(IN_TEXTBLOCK);
                    }
                    break;
                case 18:
                    image.Append(input_stream.GetSuffix(jjimageLen));
                    jjimageLen = 0;
                    if (!inComment)
                    {
                        input_stream.Backup(1);
                        inComment = true;
                        stateStackPush();
                        SwitchTo(IN_FORMAL_COMMENT);
                    }
                    break;
                case 19:
                    image.Append(input_stream.GetSuffix(jjimageLen));
                    jjimageLen = 0;
                    if (!inComment)
                    {
                        inComment = true;
                        stateStackPush();
                        SwitchTo(IN_MULTI_LINE_COMMENT);
                    }
                    break;
                case 20:
                    image.Append(input_stream.GetSuffix(jjimageLen));
                    jjimageLen = 0;
                    if (!inComment)
                    {
                        /*
                         * We can have the situation where #if($foo)$foo#end.
                         * We need to transition out of REFERENCE before going to DIRECTIVE.
                         * I don't really like this, but I can't think of a legal way
                         * you are going into DIRECTIVE while in REFERENCE.  -gmj
                         */

                        if (curLexState == REFERENCE || curLexState == REFMODIFIER)
                        {
                            inReference = false;
                            stateStackPop();
                        }

                        inDirective = true;

                        if (debugPrint)
                            Console.Write("# :  going to " + DIRECTIVE);

                        stateStackPush();
                        SwitchTo(PRE_DIRECTIVE);
                    }
                    break;
                default:
                    break;
            }
        }
        void TokenLexicalActions(Token matchedToken)
        {
            switch (jjmatchedKind)
            {
                case 1:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    stateStackPush();
                    SwitchTo(REFINDEX);
                    break;
                case 2:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    stateStackPop();
                    break;
                case 10:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    if (!inComment)
                        lparen++;

                    /*
                     * If in REFERENCE and we have seen the dot, then move
                     * to REFMOD2 -> Modifier()
                     */

                    if (curLexState == REFMODIFIER)
                        SwitchTo(REFMOD2);
                    break;
                case 11:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    RPARENHandler();
                    break;
                case 12:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    /*
                     * need to simply switch back to REFERENCE, not drop down the stack
                     * because we can (infinitely) chain, ala
                     * $foo.bar().blargh().woogie().doogie()
                     */

                    SwitchTo(REFERENCE);
                    break;
                case 14:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    if (!inComment)
                    {
                        inDirective = true;

                        if (debugPrint)
                            Console.Write("#set :  going to " + DIRECTIVE);

                        stateStackPush();
                        inSet = true;
                        SwitchTo(DIRECTIVE);
                    }

                    /*
                     *  need the LPAREN action
                     */

                    if (!inComment)
                    {
                        lparen++;

                        /*
                         * If in REFERENCE and we have seen the dot, then move
                         * to REFMOD2 -> Modifier()
                         */

                        if (curLexState == REFMODIFIER)
                            SwitchTo(REFMOD2);
                    }
                    break;
                case 21:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    if (!inComment)
                    {
                        if (curLexState == REFERENCE)
                        {
                            inReference = false;
                            stateStackPop();
                        }

                        inComment = true;
                        stateStackPush();
                        SwitchTo(IN_SINGLE_LINE_COMMENT);
                    }
                    break;
                case 25:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    inComment = false;
                    stateStackPop();
                    break;
                case 26:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    inComment = false;
                    stateStackPop();
                    break;
                case 27:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    inComment = false;
                    stateStackPop();
                    break;
                case 28:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    inComment = false;
                    stateStackPop();
                    break;
                case 32:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    /*
                     *  - if we are in DIRECTIVE and haven't seen ( yet, then also drop out.
                     *      don't forget to account for the beloved yet wierd #set
                     *  - finally, if we are in REFMOD2 (remember : $foo.bar( ) then " is ok!
                     */

                    if (curLexState == DIRECTIVE && !inSet && lparen == 0)
                        stateStackPop();
                    break;
                case 35:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    if (debugPrint)
                        Console.WriteLine(" NEWLINE :");

                    stateStackPop();

                    if (inSet)
                        inSet = false;

                    if (inDirective)
                        inDirective = false;
                    break;
                case 51:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    inDirective = false;
                    stateStackPop();
                    break;
                case 52:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    SwitchTo(DIRECTIVE);
                    break;
                case 53:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    SwitchTo(DIRECTIVE);
                    break;
                case 54:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    inDirective = false;
                    stateStackPop();
                    break;
                case 56:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    /*
                     * Remove the double period if it is there
                     */
                    if (matchedToken.image.EndsWith(".."))
                    {
                        input_stream.Backup(2);
                        matchedToken.image = matchedToken.image.Substring(0, matchedToken.image.Length - 1);
                    }

                    /*
                     * check to see if we are in set
                     *    ex.  #set $foo = $foo + 3
                     *  because we want to handle the \n after
                     */

                    if (lparen == 0 && !inSet && curLexState != REFMOD2 && curLexState != REFINDEX)
                    {
                        stateStackPop();
                    }
                    break;
                case 57:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    /*
                     * check to see if we are in set
                     *    ex.  #set $foo = $foo + 3
                     *  because we want to handle the \n after
                     */

                    if (lparen == 0 && !inSet && curLexState != REFMOD2)
                    {
                        stateStackPop();
                    }
                    break;
                case 67:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    /*
                     * push the alpha char back into the stream so the following identifier
                     * is complete
                     */

                    input_stream.Backup(1);

                    /*
                     * and munge the <DOT> so we just get a . when we have normal text that
                     * looks like a ref.ident
                     */

                    matchedToken.image = ".";

                    if (debugPrint)
                        Console.Write("DOT : switching to " + REFMODIFIER);
                    SwitchTo(REFMODIFIER);
                    break;
                case 69:
                    image.Append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
                    stateStackPop();
                    break;
                default:
                    break;
            }
        }
        private void jjCheckNAdd(int state)
        {
            if (jjrounds[state] != jjround)
            {
                jjstateSet[jjnewStateCnt++] = state;
                jjrounds[state] = jjround;
            }
        }
        private void jjAddStates(int start, int end)
        {
            do
            {
                jjstateSet[jjnewStateCnt++] = jjnextStates[start];
            } while (start++ != end);
        }
        private void jjCheckNAddTwoStates(int state1, int state2)
        {
            jjCheckNAdd(state1);
            jjCheckNAdd(state2);
        }

        private void jjCheckNAddStates(int start, int end)
        {
            do
            {
                jjCheckNAdd(jjnextStates[start]);
            } while (start++ != end);
        }

    }

}
